home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 24 / Amiga Format AFCD24 (Feb 1998, Issue 108).iso / -in_the_mag- / emulation / amiga / uae-0.7.0b2 / src / gtkui.c < prev    next >
C/C++ Source or Header  |  1998-01-20  |  13KB  |  487 lines
  1. /*
  2.  * UAE - the Un*x Amiga Emulator
  3.  *
  4.  * Yet Another User Interface for the X11 version
  5.  *
  6.  * Copyright 1997 Bernd Schmidt
  7.  * 
  8.  * The Tk GUI doesn't work.
  9.  * The X Forms Library isn't available as source, and there aren't any
  10.  * binaries compiled against glibc
  11.  *
  12.  * So let's try this...
  13.  */
  14.  
  15. #include "sysconfig.h"
  16. #include "sysdeps.h"
  17.  
  18. #include "config.h"
  19. #include "options.h"
  20. #include "uae.h"
  21. #include "memory.h"
  22. #include "custom.h"
  23. #include "readcpu.h"
  24. #include "gui.h"
  25. #include "newcpu.h"
  26. #include "threaddep/penguin.h"
  27.  
  28. #include <gtk/gtk.h>
  29.  
  30. static GtkWidget *disk_insert_widget[4], *disk_eject_widget[4], *disk_text_widget[4];
  31. static char *led_bufs[5];
  32. static int gcs_initialized = 0;
  33.  
  34. static char *disk_string[4];
  35. static char *new_disk_string[4];
  36.  
  37. static GtkWidget *led_widgets[5];
  38.  
  39. static int nr_for_led (GtkWidget *led)
  40. {
  41.     int i;
  42.     i = 0;
  43.     while (led_widgets[i] != led)
  44.     i++;
  45.     return i;
  46. }
  47.  
  48. static smp_comm_pipe to_gui_pipe, from_gui_pipe;
  49. static uae_sem_t gui_sem, gui_quit_sem;
  50.  
  51. static volatile int quit_gui = 0, quitted_gui = 0;
  52.  
  53. static void enable_disk_buttons (int enable);
  54.  
  55. static unsigned int prevledstate;
  56.  
  57. static void draw_led (int nr)
  58. {
  59.     GtkWidget *thing = led_widgets[nr];
  60.     int r = 0, g = 0, b = 0;
  61.     int i, j, k;
  62.     char *buf = led_bufs[nr];
  63.     
  64.     if (buf == 0)
  65.     return;
  66.     if (gui_ledstate & (1 << nr)) {
  67.     if (nr == 4)
  68.         r = 0xCC;
  69.     else
  70.         r = 0x88, g = 0xFF;
  71.     }
  72.     printf ("%dx%d\n", thing->allocation.width, thing->allocation.height);
  73.  
  74.     for (j = k = 0; j < thing->allocation.width; j++)
  75.     buf[k++] = r, buf[k++] = g, buf[k++] = b;
  76.     for (i = 0; i < thing->allocation.height; i++) {
  77.     gtk_preview_draw_row (GTK_PREVIEW (thing), buf, 0, i, thing->allocation.width);
  78.     }
  79.     gtk_widget_draw (thing, 0);
  80. }
  81.  
  82. static int my_idle (void)
  83. {
  84.     unsigned int leds = gui_ledstate;
  85.     int i;
  86.  
  87.     /*printf("...\n");*/
  88.     if (quit_gui) {
  89.     printf("Foo...\n");
  90.     gtk_main_quit ();
  91.     goto out;
  92.     }
  93.     while (comm_pipe_has_data (&to_gui_pipe)) {
  94.     int cmd = read_comm_pipe_int_blocking (&to_gui_pipe);
  95.     int n;
  96.     /*printf ("cmd %d\n", cmd);*/
  97.     switch (cmd) {
  98.      case 0:
  99.         n = read_comm_pipe_int_blocking (&to_gui_pipe);
  100.         gtk_label_set (GTK_LABEL (disk_text_widget[n]), currprefs.df[n]);
  101.         break;
  102.     }
  103.     }
  104.     
  105.     for (i = 0; i < 5; i++) {
  106.     unsigned int mask = 1 << i;
  107.     GtkWidget *thing;
  108.     int on = leds & mask;
  109.  
  110.     if (on == (prevledstate & mask))
  111.         continue;
  112.  
  113.     printf(": %d %d\n", i, on);
  114.     draw_led (i);
  115.     }
  116.     prevledstate = leds;
  117. out:
  118.     return 1;
  119. }
  120.  
  121. static void did_reset (void)
  122. {
  123.     if (quit_gui)
  124.     return;
  125.     
  126.     write_comm_pipe_int (&from_gui_pipe, 2, 1);
  127. }
  128.  
  129. static void did_debug (void)
  130. {
  131.     if (quit_gui)
  132.     return;
  133.     
  134.     write_comm_pipe_int (&from_gui_pipe, 3, 1);
  135. }
  136.  
  137. static void did_quit (void)
  138. {
  139.     if (quit_gui)
  140.     return;
  141.     
  142.     write_comm_pipe_int (&from_gui_pipe, 4, 1);
  143. }
  144.  
  145. static void did_eject (int n)
  146. { 
  147.     if (quit_gui)
  148.     return;
  149.     
  150.     write_comm_pipe_int (&from_gui_pipe, 0, 0);
  151.     write_comm_pipe_int (&from_gui_pipe, n, 1);
  152. }
  153.  
  154. static int filesel_active = -1;
  155. static GtkWidget *selector;
  156.  
  157. static void did_close_insert (GtkObject *o, GtkWidget *w)
  158. {
  159.     filesel_active = -1;
  160.     enable_disk_buttons (1);
  161. }
  162.  
  163. static void did_cancel_insert (GtkObject *o)
  164. {
  165.     did_close_insert (o, GTK_WIDGET (o));
  166.     gtk_widget_destroy (GTK_WIDGET (o));
  167. }
  168.  
  169. static void did_insert_select (GtkObject *o)
  170. {
  171.     char *s = gtk_file_selection_get_filename (GTK_FILE_SELECTION (selector));
  172.     
  173.     if (quit_gui)
  174.     return;
  175.     
  176.     uae_sem_wait (&gui_sem);
  177.     if (new_disk_string[filesel_active] != 0)
  178.     free (new_disk_string[filesel_active]);
  179.     new_disk_string[filesel_active] = strdup (s);
  180.     uae_sem_post (&gui_sem);
  181.     write_comm_pipe_int (&from_gui_pipe, 1, 0);
  182.     write_comm_pipe_int (&from_gui_pipe, filesel_active, 1);
  183.     did_cancel_insert (o);
  184. }
  185.  
  186. static void did_insert (int n)
  187. {
  188.     char buffer[100];
  189.  
  190.     if (filesel_active != -1)
  191.     return;
  192.     filesel_active = n;
  193.     enable_disk_buttons (0);
  194.  
  195.     sprintf (buffer, "Select a disk image file for DF%d", n);
  196.     selector = gtk_file_selection_new (buffer);
  197.     gtk_signal_connect (GTK_OBJECT (selector), "destroy",
  198.             (GtkSignalFunc) did_close_insert, selector);
  199.  
  200.     gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (selector)->ok_button),
  201.                    "clicked", (GtkSignalFunc) did_insert_select,
  202.                    GTK_OBJECT (selector));
  203.     gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (selector)->cancel_button),
  204.                    "clicked", (GtkSignalFunc) did_cancel_insert,
  205.                    GTK_OBJECT (selector));
  206.  
  207.     printf("%p\n", selector);
  208.     gtk_widget_show (selector);
  209. }
  210.  
  211. static void did_eject_0 (void) { did_eject (0); }
  212. static void did_eject_1 (void) { did_eject (1); }
  213. static void did_eject_2 (void) { did_eject (2); }
  214. static void did_eject_3 (void) { did_eject (3); }
  215.  
  216. static void did_insert_0 (void) { did_insert (0); }
  217. static void did_insert_1 (void) { did_insert (1); }
  218. static void did_insert_2 (void) { did_insert (2); }
  219. static void did_insert_3 (void) { did_insert (3); }
  220.  
  221. static void enable_disk_buttons (int enable)
  222. {
  223.     int i;
  224.     for (i = 0; i < 4; i++) {
  225.     gtk_widget_set_sensitive (disk_insert_widget[i], enable);
  226.     gtk_widget_set_sensitive (disk_eject_widget[i], enable);
  227.     }
  228. }
  229.  
  230. static gint driveled_event (GtkWidget *thing, GdkEvent *event)
  231. {
  232.     gint x, y;
  233.     GtkStyle *style;
  234.     int lednr = nr_for_led (thing);
  235.  
  236.     switch (event->type) {
  237.      case GDK_MAP:
  238.     draw_led (lednr);
  239.     break;
  240.      case GDK_EXPOSE:
  241.     if (led_bufs[lednr] == 0) {
  242.         printf ("- %d\n", thing->allocation.width);
  243.         led_bufs[lednr] = (char *)xmalloc (3 * thing->allocation.width);
  244.         draw_led (lednr);
  245.     }
  246.     break;
  247.      default:
  248.     break;
  249.     }
  250.  
  251.   return 0;
  252. }
  253.  
  254. static GtkWidget *make_led (int nr)
  255. {
  256.     GtkWidget *subframe, *the_led, *thing;
  257.     
  258.     the_led = gtk_vbox_new (FALSE, 0);
  259.     gtk_widget_set_usize (the_led, 20, -1);
  260.     gtk_widget_show (the_led);
  261.  
  262.     thing = gtk_preview_new (GTK_PREVIEW_COLOR);
  263.     gtk_box_pack_start (GTK_BOX (the_led), thing, TRUE, TRUE, 0);
  264.     gtk_widget_show (thing);
  265.  
  266.     subframe = gtk_frame_new (NULL);
  267.     gtk_box_pack_start (GTK_BOX (the_led), subframe, TRUE, TRUE, 0);
  268.     gtk_widget_show (subframe);
  269.     thing = gtk_preview_new (GTK_PREVIEW_COLOR);
  270.     gtk_container_add (GTK_CONTAINER (subframe), thing);
  271.     led_widgets[nr] = thing;
  272.     gtk_signal_connect (GTK_OBJECT (thing), "event",
  273.             (GtkSignalFunc) driveled_event, (gpointer) thing);
  274.     gtk_widget_show (thing);
  275.  
  276.     thing = gtk_preview_new (GTK_PREVIEW_COLOR);
  277.     gtk_box_pack_start (GTK_BOX (the_led), thing, TRUE, TRUE, 0);
  278.     gtk_widget_show (thing);
  279.     
  280.     return the_led;
  281. }
  282.  
  283. static void *gtk_penguin (void *dummy)
  284. {
  285.     GtkWidget *window;
  286.     GtkWidget *buttonbox, *vbox;
  287.     GtkWidget *thing;
  288.  
  289.     int i;
  290.  
  291.     int argc = 1;
  292.     char *a[] = {"UAE"};
  293.     char **argv = a;
  294.  
  295.     gtk_init (&argc, &argv);
  296.     gtk_rc_parse ("uaegtkrc");
  297.  
  298.     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  299.     gtk_widget_set_name (window, "UAE control");
  300.  
  301.     led_bufs[0] = led_bufs[1] = led_bufs[2] = led_bufs[3] = led_bufs[4] = 0;
  302.  
  303.     vbox = gtk_vbox_new (FALSE, 4);
  304.     gtk_container_add (GTK_CONTAINER (window), vbox);
  305.  
  306.     /* Make a box with the Reset/Debug/Quit buttons and place it at the top
  307.      * of our vbox.  */
  308.     buttonbox = gtk_hbox_new (FALSE, 4);
  309.     thing = gtk_button_new_with_label ("Reset");
  310.     gtk_signal_connect (GTK_OBJECT (thing), "clicked", (GtkSignalFunc) did_reset, NULL);
  311.     gtk_box_pack_start (GTK_BOX (buttonbox), thing, FALSE, TRUE, 0);
  312.     gtk_widget_show (thing);
  313.     thing = gtk_button_new_with_label ("Debug");
  314.     gtk_signal_connect (GTK_OBJECT (thing), "clicked", (GtkSignalFunc) did_debug, NULL);
  315.     gtk_box_pack_start (GTK_BOX (buttonbox), thing, FALSE, TRUE, 0);
  316.     gtk_widget_show (thing);
  317.     thing = gtk_button_new_with_label ("Quit");
  318.     gtk_signal_connect (GTK_OBJECT (thing), "clicked", (GtkSignalFunc) did_quit, NULL);
  319.     gtk_box_pack_start (GTK_BOX (buttonbox), thing, FALSE, TRUE, 0);
  320.     gtk_widget_show (thing);
  321.     thing = make_led (4);
  322.     gtk_box_pack_start (GTK_BOX (buttonbox), thing, FALSE, TRUE, 0);
  323.     gtk_widget_show (thing);
  324.     gtk_box_pack_start (GTK_BOX (vbox), buttonbox, FALSE, TRUE, 0);
  325.     gtk_widget_show (buttonbox);
  326.  
  327.     /* Place a separator below those three buttons.  */
  328.     thing = gtk_hseparator_new ();
  329.     gtk_box_pack_start (GTK_BOX (vbox), thing, FALSE, TRUE, 0);
  330.     gtk_widget_show (thing);
  331.  
  332.     /* Now, the floppy disk control.  */
  333.     for (i = 0; i < 4; i++) {
  334.     GtkWidget *subthing, *subframe;
  335.     char buf[5];
  336.     sprintf (buf, "DF%d:", i);
  337.  
  338.     /* Each line: a frame with a hbox in it. The hbox contains
  339.      * the LED, the name of the drive and the diskfile in it, an
  340.      * Insert button, and an Eject button.  */
  341.     buttonbox = gtk_frame_new (buf);
  342.     thing = gtk_hbox_new (FALSE, 4);
  343.     gtk_container_add (GTK_CONTAINER (buttonbox), thing);
  344.         gtk_box_pack_start (GTK_BOX (vbox), buttonbox, FALSE, TRUE, 0);
  345.     gtk_widget_show (buttonbox);
  346.     gtk_widget_show (thing);
  347.     buttonbox = thing;
  348.  
  349.     subthing = make_led (i);
  350.     gtk_box_pack_start (GTK_BOX (buttonbox), subthing, FALSE, TRUE, 0);
  351.  
  352.     /* Make the "DF0:xxx" label.  */
  353.     subframe = gtk_frame_new (NULL);
  354.     gtk_frame_set_shadow_type (GTK_FRAME (subframe), GTK_SHADOW_ETCHED_OUT);
  355.     gtk_box_pack_start (GTK_BOX (buttonbox), subframe, FALSE, TRUE, 0);
  356.     gtk_widget_show (subframe);
  357.  
  358.     subthing = gtk_vbox_new (FALSE, 0);
  359.     gtk_container_add (GTK_CONTAINER (subframe), subthing);
  360.     gtk_widget_show (subthing);
  361.  
  362.     /* First, an invisible preview widget to set the horizontal size.  */
  363.     thing = gtk_preview_new (GTK_PREVIEW_COLOR);
  364.     gtk_widget_set_usize (thing, gdk_string_measure (subframe->style->font, "This is a very long name for a disk file, should be enough") + 7, 0);
  365.     gtk_widget_show (thing);
  366.     gtk_box_pack_start (GTK_BOX (subthing), thing, FALSE, TRUE, 0);
  367.  
  368.     /* Then, a label with the filename.  */
  369.     thing = gtk_label_new ("frebnisia");
  370.     disk_text_widget[i] = thing;
  371.     gtk_widget_show (thing);
  372.     gtk_box_pack_start (GTK_BOX (subthing), thing, FALSE, TRUE, 0);
  373.     
  374.     /* Now, the buttons.  */
  375.     thing = gtk_button_new_with_label ("Eject");
  376.     gtk_box_pack_start (GTK_BOX (buttonbox), thing, FALSE, TRUE, 0);
  377.     gtk_widget_show (thing);
  378.     disk_eject_widget[i] = thing;
  379.     gtk_signal_connect (GTK_OBJECT (thing), "clicked",
  380.                 (GtkSignalFunc) (i == 0 ? did_eject_0 
  381.                          : i == 1 ? did_eject_1 
  382.                          : i == 2 ? did_eject_2 : did_eject_3),
  383.                 NULL);
  384.  
  385.     thing = gtk_button_new_with_label ("Insert");
  386.     gtk_box_pack_start (GTK_BOX (buttonbox), thing, FALSE, TRUE, 0);
  387.     gtk_widget_show (thing);
  388.     disk_insert_widget[i] = thing;
  389.     gtk_signal_connect (GTK_OBJECT (thing), "clicked",
  390.                 (GtkSignalFunc) (i == 0 ? did_insert_0 
  391.                          : i == 1 ? did_insert_1 
  392.                          : i == 2 ? did_insert_2 : did_insert_3),
  393.                 NULL);
  394.     }
  395.  
  396.     enable_disk_buttons (1);
  397.  
  398.     gtk_widget_show (vbox);
  399.     gtk_widget_show (window);
  400.  
  401.     gtk_timeout_add (1000, (GtkFunction)my_idle, 0);
  402.     gtk_main ();
  403.     
  404.     quitted_gui = 1;
  405.     uae_sem_post (&gui_quit_sem);
  406.     return 0;
  407. }
  408.  
  409. void gui_changesettings(void)
  410. {
  411.     
  412. }
  413.  
  414. int gui_init(void)
  415. {
  416.     penguin_id tid;
  417.  
  418.     init_comm_pipe (&to_gui_pipe, 20, 1);
  419.     init_comm_pipe (&from_gui_pipe, 20, 1);
  420.     uae_sem_init (&gui_sem, 0, 1);
  421.     uae_sem_init (&gui_quit_sem, 0, 0);
  422.     start_penguin (gtk_penguin, NULL, &tid);
  423.     return 1;
  424. }
  425.  
  426. int gui_update(void)
  427. {
  428.     return 0;
  429. }
  430.  
  431. void gui_exit(void)
  432. {
  433.     quit_gui = 1;
  434.     uae_sem_wait (&gui_quit_sem);
  435. }
  436.  
  437. void gui_led(int num, int on)
  438. {
  439. /*    if (num == 0)
  440.     return;
  441.     printf("LED %d %d\n", num, on);
  442.     write_comm_pipe_int (&to_gui_pipe, 1, 0);
  443.     write_comm_pipe_int (&to_gui_pipe, num == 0 ? 4 : num - 1, 0);
  444.     write_comm_pipe_int (&to_gui_pipe, on, 1);
  445.     printf("#LED %d %d\n", num, on);
  446.    */ 
  447. }
  448.  
  449. void gui_filename(int num, const char *name)
  450. {
  451.     write_comm_pipe_int (&to_gui_pipe, 0, 0);
  452.     write_comm_pipe_int (&to_gui_pipe, num, 1);
  453.     
  454.     gui_update ();
  455. }
  456.  
  457. void gui_handle_events(void)
  458. {
  459.     while (comm_pipe_has_data (&from_gui_pipe)) {
  460.     int cmd = read_comm_pipe_int_blocking (&from_gui_pipe);
  461.     int n;
  462.     switch (cmd) {
  463.      case 0:
  464.         n = read_comm_pipe_int_blocking (&from_gui_pipe);
  465.         changed_prefs.df[n][0] = '\0';
  466.         break;
  467.      case 1:
  468.         n = read_comm_pipe_int_blocking (&from_gui_pipe);
  469.         uae_sem_wait (&gui_sem);
  470.         strncpy (changed_prefs.df[n], new_disk_string[n], 255);
  471.         changed_prefs.df[n][255] = '\0';
  472.         uae_sem_post (&gui_sem);
  473.         break;
  474.      case 2:
  475.         uae_reset ();
  476.         break;
  477.      case 3:
  478.         activate_debugger ();
  479.         break;
  480.      case 4:
  481.         uae_quit ();
  482.         break;
  483.     }
  484.     }
  485.     
  486. }
  487.